Tutorial Intro

Generic methods in Java allow you to write methods that can operate on different data types without losing type safety. This eliminates the need to write repetitive code for similar operations on various types. Instead of creating separate methods for integers, strings, doubles, etc., you create a single generic method that can handle all of them at compile time.

Key Concepts

⯄ Type Parameters These are placeholders for actual data types. They are declared within angle brackets `< >` after the method's return type. Commonly, `T` (for "Type") is used, but you can use any valid identifier. Multiple type parameters are possible, separated by commas (e.g., `<T, U>`). ⯄ Type Inference The compiler often infers the type parameters based on the arguments passed to the generic method. This reduces the need for explicit type specifications. ⯄ Type Erasure At runtime, the Java compiler performs type erasure. This means that all type parameters are replaced with their upper bound (usually `Object`), and any type-specific operations are handled through casting. This is important for understanding how generics work under the hood.

Example 1: A Simple Generic Method

Let's create a method that finds the maximum of two values:

Simple generic method example public class Main { public static <T extends Comparable<T>> T findMax(T a, T b) { if (a.compareTo(b) > 0) { return a; } else { return b; } } public static void main(String[] args) { Integer maxInt = findMax(10, 5); // Type inference: T is inferred as Integer System.out.println("Max Integer: " + maxInt); String maxString = findMax("apple", "banana"); // Type inference: T is inferred as String System.out.println("Max String: " + maxString); Double maxDouble = findMax(3.14, 2.71); // Type inference: T is inferred as Double System.out.println("Max Double: " + maxDouble); } }

Output

Max Integer: 10 Max String: banana Max Double: 3.14

Explanation * `public static <T extends Comparable<T>> T findMax(T a, T b)`: This declares a generic method named `findMax`. * `<T extends Comparable<T>>`: This specifies that `T` must implement the `Comparable` interface. This is crucial because the `compareTo` method is used within the method to compare the two values. Without this constraint, the compiler wouldn't know how to compare instances of `T`. * `T`: The return type is also `T`, meaning the method returns a value of the same type as the input arguments. * `main` method demonstrates that the `findMax` method works correctly with various data types (Integer, String, Double) without modification.

Example 2: Multiple Type Parameters

Multiple type parameters example public class GenericMethods2 { public static <K, V> void printKeyValue(K key, V value) { System.out.println("Key: " + key + ", Value: " + value); } public static void main(String[] args) { printKeyValue("Name", "Alice"); printKeyValue(1, 100.5); } }

Output

K is String, V is String K is Integer, V is Double

Here, `printKeyValue` uses two type parameters: `K` for the key and `V` for the value. This allows it to handle key-value pairs with different types for keys and values.

Example 3: Generic Class with Generic Method

Generic Class with Generic Method class Pair { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } public T getFirst(){ return (T) this.key; } } public class Main{ public static void main(String[] args){ Pair pair = new Pair<>("hello", 10); String s = pair.getFirst(); //type inference, T is String System.out.println(s); } }

Output

hello

This example shows a generic class `Pair` with a generic method `getFirst`. Note the less safe cast in this example, illustrating the need to handle such cases carefully.

Important Considerations * Bounded Type Parameters As seen in `findMax`, you can use `extends` to specify an upper bound for the type parameter. This restricts the types that can be used. For example, `<? extends Number>` limits the type parameter to `Number` or its subtypes (Integer, Double, etc.). * Wildcard Type Parameters Wildcards (`?`) provide more flexibility. For example, `List<?>` can hold a list of any type, but you can't add elements to it without knowing the specific type. Generic methods are a powerful feature in Java that promotes code reusability and type safety. Understanding the concepts of type parameters, type inference, and type erasure is crucial to effectively using them. Remember to carefully consider bounded type parameters and wildcards to manage the flexibility and safety of your generic code.

Tutorials